import java.util.Scanner;

public class day6 {
    // 47：BC50 计算单位阶跃函数
    /*
    描述
    KiKi最近学习了信号与系统课程，这门课里有一个非常有趣的函数，单位阶跃函数，其中一种定义方式为：
    现在试求单位冲激函数在时域t上的值。
    输入描述：
    题目有多组输入数据，每一行输入一个t(-1000
    输出描述：
    输出函数的值并换行。
    示例1
    输入：
    11
    0
    - 11
    输出：
    1
    0.5
    0
    */

    public static void main47(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int t = 0;
        while (scanner.hasNextInt()) {
            t = scanner.nextInt();
            if (t > 0)
                System.out.println(1);
            else if (t == 0)
                System.out.println(0.5);
            else
                System.out.println(0);
        }
    }


    //48： BC51 三角形判断
    /*
    描述
    KiKi想知道已经给出的三条边a，b，c能否构成三角形，如果能构成三角形，判断三角形的类型（等边三角形、等腰三角形或普通三角形）。
    输入描述：
    题目有多组输入数据，每一行输入三个a，b，c(0 < a, b, c < 1000)，作为三角形的三个边，用空格分隔。
        输出描述：
        针对每组输入数据，输出占一行，如果能构成三角形，等边三角形则输出“Equilateral triangle!”，
        等腰三角形则输出“Isosceles triangle!”，其余的三角形则输出“Ordinary triangle!”，反之输出“Not a triangle!”。
        示例1
        输入：
        2 3 2
        3 3 3
        复制
        输出：
        Isosceles triangle!
        Equilateral triangle!
    */
    public static void main48(String[] args) {
        Scanner scanner = new Scanner(System.in);

        int a = 0;
        int b = 0;
        int c = 0;

        // 多组输入数据
        while (scanner.hasNextInt()) {
            a = scanner.nextInt();
            b = scanner.nextInt();
            c = scanner.nextInt();

            // 判断三角形
            if ((a + b > c) && (a + c > b) && (b + c > a)) {

                // 等边三角形
                if ((a == b) && (b == c)) {
                    System.out.println("Equilateral triangle!");

                    // 等腰三角形
                } else if ((a == b) || (b == c) || (a == c)) {
                    System.out.println("Isosceles triangle!");
                } else {  // 其余三角形
                    System.out.println("Ordinary triangle!");
                }
            } else {
                System.out.println("Not a triangle!");
            }
        }
    }

    // 方式二:
    public static void main48$2(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // 注意需要读取到“空格”分割
        while (scanner.hasNextLine()) {
            String str = scanner.nextLine();  // 需要“空格”

            String strs[] = str.split(" ");  // 以 "空格" 分割,存储到字符串数组当中
            int[] arr = new int[3];  // 存放转为 int 类型的数据

            // 循环将分割好的字符串，转换为 int 的数据类型
            for (int i = 0; i < strs.length; i++) {
                arr[i] = Integer.parseInt(strs[i]);  // 通过包装类将字符串转换为对应的(自动拆箱) int 类型的数据，注意:已经是字符串了,就不要加双引号了
            }

            // 判断三角形
            if ((arr[0] + arr[1] > arr[2]) && (arr[0] + arr[2] > arr[1]) && (arr[1] + arr[2] > arr[0])) {

                // 等边三角形
                if ((arr[0] == arr[1]) && (arr[1] == arr[2])) {
                    System.out.println("Equilateral triangle!");
                } else if ((arr[0] == arr[1]) || (arr[1] == arr[2]) || (arr[0] == arr[2])) {  // 等腰三角形
                    System.out.println("Isosceles triangle!");
                } else {  // 其余三角形
                    System.out.println("Ordinary triangle!");
                }

            } else {
                System.out.println("Not a triangle!");
            }
        }

    }

    // 49: BC52 衡量人体胖瘦程度
    /*
    描述
    在计算BMI（BodyMassIndex ，身体质量指数）的案例基础上，判断人体胖瘦程度。BMI中国标准如下表所示。
    输入描述：
    多组输入，每一行包括两个整数，用空格隔开，分别为体重（公斤）和身高（厘米）。
    输出描述：
    针对每行输入，输出为一行，人体胖瘦程度，即分类。
    示例1
    输入：
    80 170
    60 170
    90 160
    50 185
    输出：
    Overweight
    Normal
    Obese
    Underweight
    */
    // 方式一:
    public static void main49(String[] args) {
        Scanner scanner = new Scanner(System.in);
        double weigth = 0;
        double heigth = 0;

        while (scanner.hasNextDouble()) {
            weigth = scanner.nextDouble();
            heigth = scanner.nextDouble();

            double bmi = weigth / Math.pow(heigth / 100, 2.0);

            if (bmi < 18.5)
                System.out.println("Underweight");
            else if (bmi >= 18.5 && bmi <= 23.9)
                System.out.println("Normal");
            else if (bmi > 23.9 && bmi <= 27.9)
                System.out.println("Overweight");
            else
                System.out.println("Obese");

        }
    }


    // 方式二:
    public static void main49$2(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // 多组输入，注意需要“空格”分割
        while (scanner.hasNextLine()) {
            String str = scanner.nextLine();

            String[] strs = str.split(" ");  // 将字符串以"空格"分割

            int[] arr = new int[strs.length];

            for (int i = 0; i < strs.length; i++) {
                arr[i] = Integer.parseInt(strs[i]); // 将字符串转换为包装类->拆包为基本数据类型 int ,已经是字符串了就不要再加 "双引号"了
            }

            double bmi = arr[0] / Math.pow(arr[1] / 100.0, 2);

            if (bmi < 18.5)
                System.out.println("Underweight");
            else if (bmi >= 18.5 && bmi <= 23.9)
                System.out.println("Normal");
            else if (bmi > 23.9 && bmi <= 27.9)
                System.out.println("Overweight");
            else
                System.out.println("Obese");
        }
    }


    // 50：BC53 计算一元二次方程
/*
描述
从键盘输入a, b, c的值，编程计算并输出一元二次方程ax2 + bx + c = 0的根，当a = 0时，输出“Not quadratic equation”，当a ≠ 0时，根据△ = b2 - 4 * a * c的三种情况计算并输出方程的根。
输入描述：
多组输入，一行，包含三个浮点数a, b, c，以一个空格分隔，表示一元二次方程ax2 + bx + c = 0的系数。
输出描述：
针对每组输入，输出一行，输出一元二次方程ax2 + bx + c = 0的根的情况。

如果a = 0，输出“Not quadratic equation”；

如果a ≠  0，分三种情况：

△ = 0，则两个实根相等，输出形式为：x1 = x2 = ...。

△ > 0，则两个实根不等，输出形式为：x1 = ...; x2 = ...，其中x1 <= x2。

△ < 0，则有两个虚根，则输出：x1 = 实部 - 虚部i; x2 = 实部 + 虚部i，即x1的虚部系数小于等于x2的虚部系数，实部为0时不可省略。实部 = -b / (2 * a), 虚部 = sqrt(-△) / (2 * a)

    所有实数部分要求精确到小数点后2位，数字、符号之间没有空格。
    示例1
    输入：
    2.0 7.0 1.0
    输出：
    x1 = -3.35; x2 = -0.15
    示例2：
    输入：
    0.0 3.0 3.0
    输出：
    Not quadratic equation
    示例3
    输入：
    1 2 1
    输出：
    x1 = x2 = -1.00
    示例4
    输入：
    2 2 5
    输出：
    x1 = -0.50 - 1.50i; x2 = -0.50 + 1.50i
    示例5
    输入：
    1 0 1
    输出：
    x1 = 0.00 - 1.00i; x2 = 0.00 + 1.00i
*/
    public static void main50(String[] args) {
        Scanner scanner = new Scanner(System.in);
        // 多组输入
        while (scanner.hasNextDouble()) {
            double a = scanner.nextDouble();
            double b = scanner.nextDouble();
            double c = scanner.nextDouble();

            if (a != 0) {

                double disc = b * b - 4 * a * c;

                if (disc == 0) {
                    double temp = (-b) / (2 * a);

                    if (temp == 0)
                        System.out.printf("x1=x2=%.2f\n", 0.00);
                    else
                        System.out.printf("x1=x2=%.2f\n", temp);
                } else if (disc > 0) {
                    double num1 = (-b - Math.sqrt(disc)) / (2 * a);
                    double num2 = (-b + Math.sqrt(disc)) / (2 * a);
                    System.out.printf("x1=%.2f;x2=%.2f\n", num1, num2);
                } else {
                    double num3 = (-b) / (2 * a);  // 实部
                    double num4 = Math.sqrt(-disc) / (2 * a);  // 虚部

                    System.out.printf("x1=%.2f-%.2fi;x2=%.2f+%.2fi\n", num3, num4, num3, num4);
                }
            } else {
                System.out.printf("Not quadratic equation\n");
            }
        }

    }


    // 51： BC54 获得月份天数
    /*
    描述
    KiKi想获得某年某月有多少天，请帮他编程实现。输入年份和月份，计算这一年这个月有多少天。
    输入描述：
    多组输入，一行有两个整数，分别表示年份和月份，用空格分隔。
    输出描述：
    针对每组输入，输出为一行，一个整数，表示这一年这个月有多少天。
    示例1
    输入：
    2008 2
    输出：
    29
    */
    // 方式一:
    public static void main51(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int[] days = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};

        Integer year = 0;
        Integer month = 0;

        // 多组输入
        while (scanner.hasNextInt()) {
            year = scanner.nextInt();
            month = scanner.nextInt();

            Integer day = days[month - 1];

            if (2 == month)
                // 闰年判断
                if ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0))
                    ++day;
            System.out.println(day);
        }
    }

    // 方式二:
    public static void main51$2(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int[] days = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}; // 记录每月的天数信息
        // 多组数据的读取,需要“空格”
        while (scanner.hasNextLine()) {
            String str = scanner.nextLine();  // 读取空格的字符串

            String[] strs = str.split(" ");  // 将字符串以 "空格"分割

            int[] arr = new int[strs.length];  // 存放将字符串转换为基本数据类型的数据

            for (int i = 0; i < strs.length; i++) {
                arr[i] = Integer.parseInt(strs[i]);  // 通过包装类将字符串转换为 int的基本数据类型
            }

            int day = days[arr[1] - 1];  // 存放天数

            if (arr[1] == 2) {
                // 判断闰年
                if ((arr[0] % 4 == 0 && arr[0] % 100 != 0) || (arr[0] % 400 == 0)) {
                    ++day;  // 闰年 2月加 一天 +1
                }
            }

            System.out.println(day);
        }
    }


    // 52： BC55 简单计算器
    /*
    描述
    KiKi实现一个简单计算器，实现两个数的“加减乘除”运算，用户从键盘输入算式“操作数1运算符操作数2”，计算并输出表达式的值，
    如果输入的运算符号不包括在（ + 、 - 、 * 、 / ）范围内，输出“Invalid operation!”。
    当运算符为除法运算，即“ / ”时。如果操作数2等于0.0，则输出“Wrong!Division by zero!”
    数据范围：字符串长度满足 3 \le n \le 50 \3≤n≤50  ，保证运算符是一个char类型字符。
    输入描述：
    输入一行字符串，操作数1 + 运算符 + 操作数2 （其中合法的运算符包括： + 、 - 、 * 、 / ）。
    输出描述：
    输出为一行。
    如果操作数和运算符号均合法，则输出一个表达式，操作数1运算符操作数2 = 运算结果，各数小数点后均保留4位，数和符号之间没有空格。
    如果输入的运算符号不包括在（ + 、 - 、 * 、 / ）范围内，输出“Invalid operation!”。当运算符为除法运算，即“ / ”时。
    如果操作数2等于0.0，则输出“Wrong!Division by zero!”。
    示例1
    输入：
    1.0 + 3.0
    输出：
    1.0000 + 3.0000 = 4.0000
    示例2
    输入：
    1.0; 4.0
    输出：
    Invalid operation!
    示例3
    输入：
    44.0 / 0.0
    输出：
    Wrong!Division by zero!
    */
    public static void main52(String[] args) {
        Scanner scanner = new Scanner(System.in);

        String str = scanner.next();  // 读取到字符串,这里不需要空格

        String[] strs = str.split("[+\\-*/]"); // 通过+-*/进行字符串的分割,存储到字符串数组当中
        if (strs.length < 2) {
            // 如果没有输入正确的运算符或者无输入，则字符串是无法进行分割成两个部分
            System.out.println("Invalid operation!");
        } else {
            // 输入正确,将字符串通过包装类转换为对应的数值类型 double
            double num1 = Double.parseDouble(strs[0]);  // 需要注意的是已经是字符串了就不要再加"双引号"了
            double num2 = Double.parseDouble(strs[1]);

            // 通过 字符串.substring()的方法截取其中的符号,进行一个+-*/
            // 就是第一个字符串的后面的一个符号大小
            String symbol = str.substring(strs[0].length(), strs[0].length() + 1);

            switch (symbol) {  // 注意是字符串,不是字符
                case "+":
                    System.out.printf("%.4f+%.4f=%.4f\n", num1, num2, num1 + num2);
                    break;
                case "-":
                    System.out.printf("%.4f-%.4f=%.4f\n", num1, num2, num1 - num2);
                    break;
                case "*":
                    System.out.printf("%.4f*%.4f=%.4f\n", num1, num2, num1 * num2);
                    break;
                case "/":
                    if (num2 == 0)
                        System.out.printf("Wrong!Division by zero!\n");
                    else
                        System.out.printf("%.4f/%.4f=%.4f", num1, num2, num1 / num2);
                    break;
                default:
                    System.out.printf("Invalid operation!\n");
                    break;
            }

        }

    }


    // 53： BC56 线段图案
    /*
    描述
    KiKi学习了循环，BoBo老师给他出了一系列打印图案的练习，该任务是打印用“ * ”组成的线段图案。

    输入描述：
    多组输入，一个整数（1~100），表示线段长度，即“ * ”的数量。
    输出描述：
    针对每行输入，输出占一行，用“ * ”组成的对应长度的线段。
    示例1
    输入：
    10
    2
    复制
    输出：
    * *********
    **
    */

    public static void main53(String[] args) {
        Scanner scanner = new Scanner(System.in);

        while (scanner.hasNextInt()) {
            int n = scanner.nextInt();
            for (int i = 0; i < n; i++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }


    // 54. BC57 正方形图案
    /*
    描述
    KiKi学习了循环，BoBo老师给他出了一系列打印图案的练习，该任务是打印用“ * ”组成的正方形图案。
    输入描述：
    多组输入，一个整数（1~20），表示正方形的长度，也表示输出行数。

    输出描述：
    针对每行输入，输出用“ * ”组成的对应边长的正方形，每个“ * ”后面有一个空格。

    示例1
    输入：
    4
    输出：
    * ***
    ****
    ****
    ****
    示例2
    输入：
    5
    输出：
    * ****
    *****
    *****
    *****
    *****
    */

    public static void main54(String[] args) {
        Scanner scanner = new Scanner(System.in);

        while (scanner.hasNextInt()) {
            int n = scanner.nextInt();

            for (int i = 0; i < n; i++) {
                for (int j = 0; j < n; j++) {
                    System.out.print("* ");
                }
                System.out.println();
            }
        }
    }


    // 55: BC58 直角三角形图案
    /*
    描述
    KiKi学习了循环，BoBo老师给他出了一系列打印图案的练习，该任务是打印用“ * ”组成的直角三角形图案。
    输入描述：
    多组输入，一个整数（2~20），表示直角三角形直角边的长度，即“ * ”的数量，也表示输出行数。
    输出描述：
    针对每行输入，输出用“ * ”组成的对应长度的直角三角形，每个“ * ”后面有一个空格。
    示例1
    输入：
    4
    输出：
    *
    **
    ***
    ****
    示例2
    输入：
    5
    输出：
    *
    **
    ***
    ****
    *****
    */

    public static void main55(String[] args) {
        Scanner scanner = new Scanner(System.in);

        while (scanner.hasNextInt()) {
            int n = scanner.nextInt();

            for (int i = 0; i < n; i++) {
                for (int j = 0; j <= i; j++) {
                    System.out.print("* ");
                }
                System.out.println();
            }
        }
    }

    // 56： BC59 翻转直角三角形图案
    /*
    描述
    KiKi学习了循环，BoBo老师给他出了一系列打印图案的练习，该任务是打印用“ * ”组成的翻转直角三角形图案。
    输入描述：
    多组输入，一个整数（2~20），表示翻转直角三角形直角边的长度，即“ * ”的数量，也表示输出行数。
    输出描述：
    针对每行输入，输出用“ * ”组成的对应长度的翻转直角三角形，每个“ * ”后面有一个空格。
    示例1
    输入：
    5
    输出：
    * ****
    ****
    ***
    **
    *
    示例2
    输入：
    6
    输出：
    * *****
    *****
    ****
    ***
    **
    *
    */
    public static void main56(String[] args) {
        Scanner scanner = new Scanner(System.in);

        while (scanner.hasNextInt()) {
            int n = scanner.nextInt();

            for (int i = 0; i < n; i++) {
                for (int j = 0; j < n - i; j++) {
                    System.out.print("* ");
                }
                System.out.println();
            }
        }
    }


    // 57:BC60 带空格直角三角形图案
    /*
    描述
    KiKi学习了循环，BoBo老师给他出了一系列打印图案的练习，该任务是打印用“ * ”组成的带空格直角三角形图案。

    输入描述：
    多组输入，一个整数（2~20），表示直角三角形直角边的长度，即“ * ”的数量，也表示输出行数。

    输出描述：
    针对每行输入，输出用“ * ”组成的对应长度的直角三角形，每个“ * ”后面有一个空格。

    示例1
    输入：
    5
    输出：
    *
    **
    ***
    ****
    *****
    示例2
    输入：
    4
    输出：
    *
    **
    ***
    ****
    */
    public static void main57(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // 多组输入
        while (scanner.hasNextInt()) {
            int n = scanner.nextInt();

            for (int i = 0; i < n; i++) {
                // 两个空格
                for (int j = 0; j < n - i - 1; j++) {
                    System.out.print("  ");
                }

                // 星号
                for (int j = 0; j <= i; j++) {
                    System.out.print("* "); // 加空格
                }
                System.out.println();
            }
        }
    }

    // 方式二:
    public static void main57$2(String[] args) {
        Scanner scanner = new Scanner(System.in);

        while (scanner.hasNextInt()) {
            int n = scanner.nextInt();

            for (int i = 0; i < n; i++) {
                for (int j = 0; j < n; j++) {
                    // 打印空格
                    if ((i + j) < n - 1) {
                        System.out.print("  ");  // 两个空格
                    } else {
                        System.out.print("* ");
                    }
                }
                System.out.println();
            }
        }
    }


}
